11 research outputs found
Data dependent energy modelling for worst case energy consumption analysis
Safely meeting Worst Case Energy Consumption (WCEC) criteria requires
accurate energy modeling of software. We investigate the impact of instruction
operand values upon energy consumption in cacheless embedded processors.
Existing instruction-level energy models typically use measurements from random
input data, providing estimates unsuitable for safe WCEC analysis.
We examine probabilistic energy distributions of instructions and propose a
model for composing instruction sequences using distributions, enabling WCEC
analysis on program basic blocks. The worst case is predicted with statistical
analysis. Further, we verify that the energy of embedded benchmarks can be
characterised as a distribution, and compare our proposed technique with other
methods of estimating energy consumption
EACOF: A Framework for Providing Energy Transparency to enable Energy-Aware Software Development
Making energy consumption data accessible to software developers is an
essential step towards energy efficient software engineering. The presence of
various different, bespoke and incompatible, methods of instrumentation to
obtain energy readings is currently limiting the widespread use of energy data
in software development. This paper presents EACOF, a modular Energy-Aware
Computing Framework that provides a layer of abstraction between sources of
energy data and the applications that exploit them. EACOF replaces platform
specific instrumentation through two APIs - one accepts input to the framework
while the other provides access to application software. This allows developers
to profile their code for energy consumption in an easy and portable manner
using simple API calls. We outline the design of our framework and provide
details of the API functionality. In a use case, where we investigate the
impact of data bit width on the energy consumption of various sorting
algorithms, we demonstrate that the data obtained using EACOF provides
interesting, sometimes counter-intuitive, insights. All the code is available
online under an open source license. http://github.com/eaco
Inferring Energy Bounds via Static Program Analysis and Evolutionary Modeling of Basic Blocks
The ever increasing number and complexity of energy-bound devices (such as
the ones used in Internet of Things applications, smart phones, and mission
critical systems) pose an important challenge on techniques to optimize their
energy consumption and to verify that they will perform their function within
the available energy budget. In this work we address this challenge from the
software point of view and propose a novel parametric approach to estimating
tight bounds on the energy consumed by program executions that are practical
for their application to energy verification and optimization. Our approach
divides a program into basic (branchless) blocks and estimates the maximal and
minimal energy consumption for each block using an evolutionary algorithm. Then
it combines the obtained values according to the program control flow, using
static analysis, to infer functions that give both upper and lower bounds on
the energy consumption of the whole program and its procedures as functions on
input data sizes. We have tested our approach on (C-like) embedded programs
running on the XMOS hardware platform. However, our method is general enough to
be applied to other microprocessor architectures and programming languages. The
bounds obtained by our prototype implementation can be tight while remaining on
the safe side of budgets in practice, as shown by our experimental evaluation.Comment: Pre-proceedings paper presented at the 27th International Symposium
on Logic-Based Program Synthesis and Transformation (LOPSTR 2017), Namur,
Belgium, 10-12 October 2017 (arXiv:1708.07854). Improved version of the one
presented at the HIP3ES 2016 workshop (v1): more experimental results (added
benchmark to Table 1, added figure for new benchmark, added Table 3),
improved Fig. 1, added Fig.
Pećnjaci Garić grada
Funding: This work was supported by the EU Horizon 2020 project, Team-Play (https://www.teamplay-h2020.eu), grant number 779882, and UK EPSRC Discovery, grant number EP/P020631/1.Energy, Time and Security (ETS) properties of programs are becoming increasingly prioritised by developers, especially where applications are running on ETS sensitive systems, such as embedded devices or the Internet of Things. Moreover, developers currently lack tools and language properties to allow them to reason about ETS. In this paper, we introduce a new contract specification frame-work, called Drive, which allows a developer to reason about ETS or other non-functional properties of their programs as first-class properties of the language. Furthermore, we introduce a contract specification language, allowing developers to reason about these first-class ETS properties by expressing contracts that are proved correct by an underlying formal type system. Finally, we show our contract framework over a number of representable examples, demonstrating provable worst-case ETS properties.Postprin
Multivariant Assertion-based Guidance in Abstract Interpretation
Approximations during program analysis are a necessary evil, as they ensure
essential properties, such as soundness and termination of the analysis, but
they also imply not always producing useful results. Automatic techniques have
been studied to prevent precision loss, typically at the expense of larger
resource consumption. In both cases (i.e., when analysis produces inaccurate
results and when resource consumption is too high), it is necessary to have
some means for users to provide information to guide analysis and thus improve
precision and/or performance. We present techniques for supporting within an
abstract interpretation framework a rich set of assertions that can deal with
multivariance/context-sensitivity, and can handle different run-time semantics
for those assertions that cannot be discharged at compile time. We show how the
proposed approach can be applied to both improving precision and accelerating
analysis. We also provide some formal results on the effects of such assertions
on the analysis results.Comment: Pre-proceedings paper presented at the 28th International Symposium
on Logic-Based Program Synthesis and Transformation (LOPSTR 2018), Frankfurt
am Main, Germany, 4-6 September 2018 (arXiv:1808.03326
Inferring energy bounds via static program analysis and evolutionary modeling of basic blocks
The ever increasing number and complexity of energy-bound
devices (such as the ones used in Internet of Things applications, smart
phones, and mission critical systems) pose an important challenge on
techniques to optimize their energy consumption and to verify that they
will perform their function within the available energy budget. In this
work we address this challenge from the software point of view and propose
a novel approach to estimating accurate parametric bounds on the
energy consumed by program executions that are practical for their application
to energy verification and optimization. Our approach divides a
program into basic (branchless) blocks and performs a best effort modeling
to estimate upper and lower bounds on the energy consumption
for each block using an evolutionary algorithm. Then it combines the
obtained values according to the program control flow, using a safe static
analysis, to infer functions that give both upper and lower bounds on the
energy consumption of the whole program and its procedures as functions
on input data sizes. We have tested our approach on (C-like) embedded
programs running on the XMOS hardware platform. However, our
method is general enough to be applied to other microprocessor architectures
and programming languages. The bounds obtained by our prototype
implementation on a set of benchmarks were always safe and quite
accurate. This supports our hypothesis that our approach offers a good
compromise between safety and accuracy, and can be applied in practice
for energy verification and optimization
Skylines for Symbolic Energy Consumption Analysis
Contains fulltext :
222055.pdf (Publisher’s version ) (Open Access)FMICS'2
Inferring Parametric Energy Consumption Functions at Different Software Levels:ISA vs. LLVM IR
The static estimation of the energy consumed by program executions is an
important challenge, which has applications in program optimization and
verification, and is instrumental in energy-aware software development. Our
objective is to estimate such energy consumption in the form of functions on
the input data sizes of programs. We have developed a tool for experimentation
with static analysis which infers such energy functions at two levels, the
instruction set architecture (ISA) and the intermediate code (LLVM IR) levels,
and reflects it upwards to the higher source code level. This required the
development of a translation from LLVM IR to an intermediate representation and
its integration with existing components, a translation from ISA to the same
representation, a resource analyzer, an ISA-level energy model, and a mapping
from this model to LLVM IR. The approach has been applied to programs written
in the XC language running on XCore architectures, but is general enough to be
applied to other languages. Experimental results show that our LLVM IR level
analysis is reasonably accurate (less than 6.4% average error vs. hardware
measurements) and more powerful than analysis at the ISA level. This paper
provides insights into the trade-off of precision versus analyzability at these
levels.Comment: 22 pages, 4 figures, 2 table
Probabilistic Resource Analysis by Program Transformation
The aim of a probabilistic resource analysis is to derive a probability
distribution of possible resource usage for a program from a probability
distribution of its input. We present an automated multi- phase rewriting based
method to analyze programs written in a subset of C. It generates a probability
distribution of the resource usage as a possibly uncomputable expression and
then transforms it into a closed form expression using over-approximations. We
present the technique, outline the implementation and show results from
experiments with the system